{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def get_kernel_size(factor):\n",
    "    \"\"\"\n",
    "    Find the kernel size given the desired factor of upsampling.\n",
    "    \"\"\"\n",
    "    return 2 * factor - factor % 2\n",
    "\n",
    "\n",
    "def upsample_filt(size):\n",
    "    \"\"\"\n",
    "    Make a 2D bilinear kernel suitable for upsampling of the given (h, w) size.\n",
    "    \"\"\"\n",
    "    factor = (size + 1) // 2\n",
    "    if size % 2 == 1:\n",
    "        center = factor - 1\n",
    "    else:\n",
    "        center = factor - 0.5\n",
    "    og = np.ogrid[:size, :size]\n",
    "    return (1 - abs(og[0] - center) / factor) * \\\n",
    "           (1 - abs(og[1] - center) / factor)\n",
    "\n",
    "\n",
    "def bilinear_upsample_weights(factor, number_of_classes):\n",
    "    \"\"\"\n",
    "    Create weights matrix for transposed convolution with bilinear filter\n",
    "    initialization.\n",
    "    \"\"\"\n",
    "\n",
    "    filter_size = get_kernel_size(factor)\n",
    "\n",
    "    weights = np.zeros(\n",
    "        (filter_size, filter_size, number_of_classes, number_of_classes),\n",
    "        dtype=np.float32)\n",
    "\n",
    "    upsample_kernel = upsample_filt(filter_size)\n",
    "\n",
    "    for i in range(number_of_classes):\n",
    "\n",
    "        weights[:, :, i, i] = upsample_kernel\n",
    "\n",
    "    return weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "slim = tf.contrib.slim\n",
    "\n",
    "from nets import vgg\n",
    "from preprocessing import vgg_preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = '0'\n",
    "\n",
    "checkpoints_dir = os.path.expanduser('data/pre_trained/')\n",
    "\n",
    "image_filename = 'data/object_1.jpg'\n",
    "annotation_filename = 'data/segment_1.png'\n",
    "\n",
    "fig_size = [15, 4]\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "image_filename_placeholder = tf.placeholder(tf.string)\n",
    "annotation_filename_placeholder = tf.placeholder(tf.string)\n",
    "is_training_placeholder = tf.placeholder(tf.bool)\n",
    "\n",
    "feed_dict_to_use = {\n",
    "    image_filename_placeholder: image_filename,\n",
    "    annotation_filename_placeholder: annotation_filename,\n",
    "    is_training_placeholder: True\n",
    "}\n",
    "\n",
    "image_tensor = tf.read_file(image_filename_placeholder)\n",
    "annotation_tensor = tf.read_file(annotation_filename_placeholder)\n",
    "\n",
    "image_tensor = tf.image.decode_jpeg(image_tensor, channels=3)\n",
    "annotation_tensor = tf.image.decode_png(annotation_tensor, channels=1)\n",
    "\n",
    "# Get ones for each class instead of a number -- we need that\n",
    "# for cross-entropy loss later on. Sometimes the groundtruth\n",
    "# masks have values other than 1 and 0.\n",
    "class_labels_tensor = tf.greater_equal(annotation_tensor, 1)\n",
    "background_labels_tensor = tf.less(annotation_tensor, 1)\n",
    "\n",
    "# Convert the boolean values into floats -- so that\n",
    "# computations in cross-entropy loss is correct\n",
    "bit_mask_class = tf.to_float(class_labels_tensor)\n",
    "bit_mask_background = tf.to_float(background_labels_tensor)\n",
    "\n",
    "combined_mask = tf.concat(\n",
    "    axis=2, values=[\n",
    "        bit_mask_background,\n",
    "        bit_mask_class,\n",
    "    ])\n",
    "\n",
    "# Lets reshape our input so that it becomes suitable for\n",
    "# tf.softmax_cross_entropy_with_logits with [batch_size, num_classes]\n",
    "flat_labels = tf.reshape(tensor=combined_mask, shape=(-1, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the mean pixel values and the function\n",
    "# that performs the subtraction from each pixel\n",
    "from preprocessing.vgg_preprocessing import (_mean_image_subtraction, _R_MEAN,\n",
    "                                             _G_MEAN, _B_MEAN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('vgg_16/conv1/conv1_1', <tf.Tensor 'vgg_16/conv1/conv1_1/Relu:0' shape=(1, ?, ?, 64) dtype=float32>), ('vgg_16/conv1/conv1_2', <tf.Tensor 'vgg_16/conv1/conv1_2/Relu:0' shape=(1, ?, ?, 64) dtype=float32>), ('vgg_16/pool1', <tf.Tensor 'vgg_16/pool1/MaxPool:0' shape=(1, ?, ?, 64) dtype=float32>), ('vgg_16/conv2/conv2_1', <tf.Tensor 'vgg_16/conv2/conv2_1/Relu:0' shape=(1, ?, ?, 128) dtype=float32>), ('vgg_16/conv2/conv2_2', <tf.Tensor 'vgg_16/conv2/conv2_2/Relu:0' shape=(1, ?, ?, 128) dtype=float32>), ('vgg_16/pool2', <tf.Tensor 'vgg_16/pool2/MaxPool:0' shape=(1, ?, ?, 128) dtype=float32>), ('vgg_16/conv3/conv3_1', <tf.Tensor 'vgg_16/conv3/conv3_1/Relu:0' shape=(1, ?, ?, 256) dtype=float32>), ('vgg_16/conv3/conv3_2', <tf.Tensor 'vgg_16/conv3/conv3_2/Relu:0' shape=(1, ?, ?, 256) dtype=float32>), ('vgg_16/conv3/conv3_3', <tf.Tensor 'vgg_16/conv3/conv3_3/Relu:0' shape=(1, ?, ?, 256) dtype=float32>), ('vgg_16/pool3', <tf.Tensor 'vgg_16/pool3/MaxPool:0' shape=(1, ?, ?, 256) dtype=float32>), ('vgg_16/conv4/conv4_1', <tf.Tensor 'vgg_16/conv4/conv4_1/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/conv4/conv4_2', <tf.Tensor 'vgg_16/conv4/conv4_2/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/conv4/conv4_3', <tf.Tensor 'vgg_16/conv4/conv4_3/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/pool4', <tf.Tensor 'vgg_16/pool4/MaxPool:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/conv5/conv5_1', <tf.Tensor 'vgg_16/conv5/conv5_1/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/conv5/conv5_2', <tf.Tensor 'vgg_16/conv5/conv5_2/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/conv5/conv5_3', <tf.Tensor 'vgg_16/conv5/conv5_3/Relu:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/pool5', <tf.Tensor 'vgg_16/pool5/MaxPool:0' shape=(1, ?, ?, 512) dtype=float32>), ('vgg_16/fc6', <tf.Tensor 'vgg_16/fc6/Relu:0' shape=(1, ?, ?, 4096) dtype=float32>), ('vgg_16/fc7', <tf.Tensor 'vgg_16/fc7/Relu:0' shape=(1, ?, ?, 4096) dtype=float32>), ('vgg_16/fc8', <tf.Tensor 'vgg_16/fc8/BiasAdd:0' shape=(1, ?, ?, 2) dtype=float32>)])\n"
     ]
    }
   ],
   "source": [
    "upsample_factor = 8\n",
    "number_of_classes = 2\n",
    "log_folder = os.path.expanduser('segment_log_folder')\n",
    "\n",
    "vgg_checkpoint_path = os.path.join(checkpoints_dir, 'vgg_16.ckpt')\n",
    "\n",
    "# Convert image to float32 before subtracting the\n",
    "# mean pixel value\n",
    "image_float = tf.to_float(image_tensor, name='ToFloat')\n",
    "\n",
    "original_shape = tf.shape(image_float)[0:2]\n",
    "\n",
    "# Subtract the mean pixel value from each pixel\n",
    "mean_centered_image = _mean_image_subtraction(image_float,\n",
    "                                              [_R_MEAN, _G_MEAN, _B_MEAN])\n",
    "\n",
    "target_input_size_factor = tf.ceil(\n",
    "    tf.div(tf.to_float(original_shape), tf.to_float(upsample_factor)))\n",
    "target_input_size = tf.to_int32(\n",
    "    tf.multiply(target_input_size_factor, upsample_factor))\n",
    "padding_size = (target_input_size - original_shape) // 2\n",
    "\n",
    "mean_centered_image = tf.image.pad_to_bounding_box(\n",
    "    mean_centered_image, padding_size[0], padding_size[1],\n",
    "    target_input_size[0], target_input_size[1])\n",
    "\n",
    "processed_images = tf.expand_dims(mean_centered_image, 0)\n",
    "\n",
    "# Define the model that we want to use -- specify to use only two classes at the last layer\n",
    "with slim.arg_scope(vgg.vgg_arg_scope()):\n",
    "\n",
    "    logits, end_points = vgg.vgg_16(\n",
    "        processed_images,\n",
    "        num_classes=2,\n",
    "        is_training=is_training_placeholder,\n",
    "        spatial_squeeze=False,\n",
    "        fc_conv_padding='SAME')\n",
    "print(end_points)\n",
    "\n",
    "downsampled_logits_shape = tf.shape(logits)\n",
    "\n",
    "# Calculate the ouput size of the upsampled tensor\n",
    "upsampled_logits_shape = tf.stack([\n",
    "    downsampled_logits_shape[0],\n",
    "    original_shape[0],  #downsampled_logits_shape[1] * upsample_factor,\n",
    "    original_shape[1],  #downsampled_logits_shape[2] * upsample_factor,\n",
    "    downsampled_logits_shape[3]\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#取出pool4的feature map\n",
    "pool4_feature = end_points['vgg_16/pool4']\n",
    "\n",
    "#对pool4的feature map施加一个分类器，用1x1的卷积核，不改变feature map的大小，\n",
    "#分类器输出的feature map的大小为原图的16分之一，取名叫aux_logits_16s\n",
    "with tf.variable_scope('vgg_16/fc8'):\n",
    "    aux_logits_16s = slim.conv2d(pool4_feature, 2, [1, 1],\n",
    "                                 activation_fn=None,\n",
    "                                 weights_initializer=tf.zeros_initializer,\n",
    "                                 scope='conv_pool4')\n",
    "\n",
    "# 构建双线性插值权重矩阵，作用是对feature map进行两倍上采样\n",
    "upsample_filter_np_x2 = bilinear_upsample_weights(2,  # upsample_factor,\n",
    "                                                  number_of_classes)\n",
    "\n",
    "# 将权重矩阵设为变量，可优化\n",
    "upsample_filter_tensor_x2 = tf.Variable(upsample_filter_np_x2, name='vgg_16/fc8/t_conv_x2')\n",
    "\n",
    "# 对logits进行2倍上采样（反卷积），变为原图大小的16分之一\n",
    "upsampled_logits_16s = tf.nn.conv2d_transpose(logits, upsample_filter_tensor_x2,\n",
    "                                          output_shape=tf.shape(aux_logits_16s),\n",
    "                                          strides=[1, 2, 2, 1],\n",
    "                                          padding='SAME')\n",
    "\n",
    "\n",
    "# logits 2倍上采样的输出为upsampled_logits_16s\n",
    "# pool4的feature map经过分类器的输出为aux_logits_16s\n",
    "# 将两个输出加起来，结果依然是原图大小的16分之一\n",
    "upsampled_logits_16s = upsampled_logits_16s + aux_logits_16s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 取出pool3的feature map\n",
    "pool3_feature = end_points['vgg_16/pool3']\n",
    "\n",
    "#对pool3的feature map施加一个分类器，用1x1的卷积核，不改变feature map的大小，\n",
    "#分类器输出的feature map的大小为原图的8分之一，取名叫aux_logits_8s\n",
    "with tf.variable_scope('vgg_16/fc8'):\n",
    "    aux_logits_8s = slim.conv2d(pool3_feature, 2, [1, 1],\n",
    "                                 activation_fn=None,\n",
    "                                 weights_initializer=tf.zeros_initializer,\n",
    "                                 scope='conv_pool3')\n",
    "\n",
    "# 构建两倍上采样的双线性插值权重矩阵\n",
    "upsample_filter_np_x2_pool3 = bilinear_upsample_weights(2,  # upsample_factor,\n",
    "                                                  number_of_classes)\n",
    "\n",
    "upsample_filter_tensor_x2_pool3 = tf.Variable(upsample_filter_np_x2_pool3, name='vgg_16/fc8/t_conv_x2_pool3')\n",
    "\n",
    "# 对upsampled_logits_16s进行2倍上采样（反卷积），变为原图大小的8分之\n",
    "upsampled_logits_8s = tf.nn.conv2d_transpose(upsampled_logits_16s, upsample_filter_tensor_x2_pool3,\n",
    "                                          output_shape=tf.shape(aux_logits_8s),\n",
    "                                          strides=[1, 2, 2, 1],\n",
    "                                          padding='SAME')\n",
    "\n",
    "# upsampled_logits_16s 2倍上采样的输出为upsampled_logits_8s\n",
    "# pool3的feature map经过分类器的输出为aux_logits_8s\n",
    "# 将两个输出加起来，结果是原图大小的8分之一\n",
    "upsampled_logits_8s = upsampled_logits_8s + aux_logits_8s\n",
    "\n",
    "# 构建8倍上采样的双线性插值权重矩阵\n",
    "upsample_filter_np_x8 = bilinear_upsample_weights(upsample_factor,\n",
    "                                                   number_of_classes)\n",
    "\n",
    "upsample_filter_tensor_x8 = tf.Variable(upsample_filter_np_x8, name='vgg_16/fc8/t_conv_x8')\n",
    "\n",
    "# 对upsampled_logits_8s进行8倍上采样（反卷积），变为跟原图等大\n",
    "upsampled_logits = tf.nn.conv2d_transpose(upsampled_logits_8s, upsample_filter_tensor_x8,\n",
    "                                          output_shape=upsampled_logits_shape,\n",
    "                                          strides=[1, upsample_factor, upsample_factor, 1],\n",
    "                                          padding='SAME')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Flatten the predictions, so that we can compute cross-entropy for\n",
    "# each pixel and get a sum of cross-entropies.\n",
    "flat_logits = tf.reshape(\n",
    "    tensor=upsampled_logits, shape=(-1, number_of_classes))\n",
    "\n",
    "cross_entropies = tf.nn.softmax_cross_entropy_with_logits(\n",
    "    logits=flat_logits, labels=flat_labels)\n",
    "\n",
    "cross_entropy_sum = tf.reduce_sum(cross_entropies)\n",
    "\n",
    "# Tensor to get the final prediction for each pixel -- pay\n",
    "# attention that we don't need softmax in this case because\n",
    "# we only need the final decision. If we also need the respective\n",
    "# probabilities we will have to apply softmax.\n",
    "pred = tf.argmax(upsampled_logits, axis=3)\n",
    "\n",
    "probabilities = tf.nn.softmax(upsampled_logits)\n",
    "\n",
    "# Here we define an optimizer and put all the variables\n",
    "# that will be created under a namespace of 'adam_vars'.\n",
    "# This is done so that we can easily access them later.\n",
    "# Those variables are used by adam optimizer and are not\n",
    "# related to variables of the vgg model.\n",
    "\n",
    "# We also retrieve gradient Tensors for each of our variables\n",
    "# This way we can later visualize them in tensorboard.\n",
    "# optimizer.compute_gradients and optimizer.apply_gradients\n",
    "# is equivalent to running:\n",
    "# train_step = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(cross_entropy_sum)\n",
    "with tf.variable_scope(\"adam_vars\"):\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)\n",
    "    gradients = optimizer.compute_gradients(loss=cross_entropy_sum)\n",
    "\n",
    "    for grad_var_pair in gradients:\n",
    "\n",
    "        current_variable = grad_var_pair[1]\n",
    "        current_gradient = grad_var_pair[0]\n",
    "\n",
    "        # Relace some characters from the original variable name\n",
    "        # tensorboard doesn't accept ':' symbol\n",
    "        gradient_name_to_save = current_variable.name.replace(\":\", \"_\")\n",
    "\n",
    "        # Let's get histogram of gradients for each layer and\n",
    "        # visualize them later in tensorboard\n",
    "        tf.summary.histogram(gradient_name_to_save, current_gradient)\n",
    "\n",
    "    train_step = optimizer.apply_gradients(grads_and_vars=gradients)\n",
    "\n",
    "# Now we define a function that will load the weights from VGG checkpoint\n",
    "# into our variables when we call it. We exclude the weights from the last layer\n",
    "# which is responsible for class predictions. We do this because\n",
    "# we will have different number of classes to predict and we can't\n",
    "# use the old ones as an initialization.\n",
    "vgg_except_fc8_weights = slim.get_variables_to_restore(\n",
    "    exclude=['vgg_16/fc8', 'adam_vars'])\n",
    "\n",
    "# Here we get variables that belong to the last layer of network.\n",
    "# As we saw, the number of classes that VGG was originally trained on\n",
    "# is different from ours -- in our case it is only 2 classes.\n",
    "vgg_fc8_weights = slim.get_variables_to_restore(include=['vgg_16/fc8'])\n",
    "\n",
    "adam_optimizer_variables = slim.get_variables_to_restore(include=['adam_vars'])\n",
    "\n",
    "# Add summary op for the loss -- to be able to see it in\n",
    "# tensorboard.\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_sum)\n",
    "\n",
    "# Put all summary ops into one op. Produces string when\n",
    "# you run it.\n",
    "merged_summary_op = tf.summary.merge_all()\n",
    "\n",
    "# Create the summary writer -- to write all the logs\n",
    "# into a specified file. This file can be later read\n",
    "# by tensorboard.\n",
    "summary_string_writer = tf.summary.FileWriter(log_folder)\n",
    "\n",
    "# Create the log folder if doesn't exist yet\n",
    "if not os.path.exists(log_folder):\n",
    "    os.makedirs(log_folder)\n",
    "\n",
    "# Create an OP that performs the initialization of\n",
    "# values of variables to the values from VGG.\n",
    "read_vgg_weights_except_fc8_func = slim.assign_from_checkpoint_fn(\n",
    "    vgg_checkpoint_path, vgg_except_fc8_weights)\n",
    "\n",
    "# Initializer for new fc8 weights -- for two classes.\n",
    "vgg_fc8_weights_initializer = tf.variables_initializer(vgg_fc8_weights)\n",
    "\n",
    "# Initializer for adam variables\n",
    "optimization_variables_initializer = tf.variables_initializer(\n",
    "    adam_optimizer_variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from data/pre_trained/vgg_16.ckpt\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "InvalidArgumentError",
     "evalue": "2 root error(s) found.\n  (0) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[node conv2d_transpose (defined at <ipython-input-28-5ac50f1105ca>:23) ]]\n\t [[adam_vars/gradients/vgg_16/fc8_2/conv_pool3/BiasAdd_grad/BiasAddGrad/_99]]\n  (1) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[node conv2d_transpose (defined at <ipython-input-28-5ac50f1105ca>:23) ]]\n0 successful operations.\n0 derived errors ignored.\n\nErrors may have originated from an input operation.\nInput Source operations connected to node conv2d_transpose:\n Shape_2 (defined at <ipython-input-28-5ac50f1105ca>:21)\t\n vgg_16/fc8/t_conv_x2/read (defined at <ipython-input-28-5ac50f1105ca>:17)\t\n vgg_16/fc8/BiasAdd (defined at C:\\Users\\ZHAOJU~1\\AppData\\Local\\Temp\\tmp_w6k0wcb.py:56)\n\nInput Source operations connected to node conv2d_transpose:\n Shape_2 (defined at <ipython-input-28-5ac50f1105ca>:21)\t\n vgg_16/fc8/t_conv_x2/read (defined at <ipython-input-28-5ac50f1105ca>:17)\t\n vgg_16/fc8/BiasAdd (defined at C:\\Users\\ZHAOJU~1\\AppData\\Local\\Temp\\tmp_w6k0wcb.py:56)\n\nOriginal stack trace for 'conv2d_transpose':\n  File \"D:\\Anaconda\\lib\\runpy.py\", line 193, in _run_module_as_main\n    \"__main__\", mod_spec)\n  File \"D:\\Anaconda\\lib\\runpy.py\", line 85, in _run_code\n    exec(code, run_globals)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py\", line 16, in <module>\n    app.launch_new_instance()\n  File \"D:\\Anaconda\\lib\\site-packages\\traitlets\\config\\application.py\", line 664, in launch_instance\n    app.start()\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 563, in start\n    self.io_loop.start()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 148, in start\n    self.asyncio_loop.run_forever()\n  File \"D:\\Anaconda\\lib\\asyncio\\base_events.py\", line 534, in run_forever\n    self._run_once()\n  File \"D:\\Anaconda\\lib\\asyncio\\base_events.py\", line 1771, in _run_once\n    handle._run()\n  File \"D:\\Anaconda\\lib\\asyncio\\events.py\", line 88, in _run\n    self._context.run(self._callback, *self._args)\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\ioloop.py\", line 690, in <lambda>\n    lambda f: self._run_callback(functools.partial(callback, future))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\ioloop.py\", line 743, in _run_callback\n    ret = callback()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 787, in inner\n    self.run()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 748, in run\n    yielded = self.gen.send(value)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 365, in process_one\n    yield gen.maybe_future(dispatch(*args))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 272, in dispatch_shell\n    yield gen.maybe_future(handler(stream, idents, msg))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 542, in execute_request\n    user_expressions, allow_stdin,\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 294, in do_execute\n    res = shell.run_cell(code, store_history=store_history, silent=silent)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 536, in run_cell\n    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2855, in run_cell\n    raw_cell, store_history, silent, shell_futures)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2881, in _run_cell\n    return runner(coro)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 68, in _pseudo_sync_runner\n    coro.send(None)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3058, in run_cell_async\n    interactivity=interactivity, compiler=compiler, result=result)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3249, in run_ast_nodes\n    if (await self.run_code(code, result,  async_=asy)):\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3326, in run_code\n    exec(code_obj, self.user_global_ns, self.user_ns)\n  File \"<ipython-input-28-5ac50f1105ca>\", line 23, in <module>\n    padding='SAME')\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\nn_ops.py\", line 2147, in conv2d_transpose\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\nn_ops.py\", line 2218, in conv2d_transpose_v2\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\gen_nn_ops.py\", line 1529, in conv2d_backprop_input\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py\", line 788, in _apply_op_helper\n    op_def=op_def)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\util\\deprecation.py\", line 507, in new_func\n    return func(*args, **kwargs)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\", line 3616, in create_op\n    op_def=op_def)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\", line 2005, in __init__\n    self._traceback = tf_stack.extract_stack()\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_do_call\u001b[1;34m(self, fn, *args)\u001b[0m\n\u001b[0;32m   1355\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1356\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1357\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_run_fn\u001b[1;34m(feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[0;32m   1340\u001b[0m       return self._call_tf_sessionrun(\n\u001b[1;32m-> 1341\u001b[1;33m           options, feed_dict, fetch_list, target_list, run_metadata)\n\u001b[0m\u001b[0;32m   1342\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_call_tf_sessionrun\u001b[1;34m(self, options, feed_dict, fetch_list, target_list, run_metadata)\u001b[0m\n\u001b[0;32m   1428\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1429\u001b[1;33m         run_metadata)\n\u001b[0m\u001b[0;32m   1430\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mInvalidArgumentError\u001b[0m: 2 root error(s) found.\n  (0) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[{{node conv2d_transpose}}]]\n\t [[adam_vars/gradients/vgg_16/fc8_2/conv_pool3/BiasAdd_grad/BiasAddGrad/_99]]\n  (1) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[{{node conv2d_transpose}}]]\n0 successful operations.\n0 derived errors ignored.",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-8c8cf7d6ab09>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     24\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     25\u001b[0m         loss, summary_string = sess.run(\n\u001b[1;32m---> 26\u001b[1;33m             [cross_entropy_sum, merged_summary_op], feed_dict=feed_dict_to_use)\n\u001b[0m\u001b[0;32m     27\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     28\u001b[0m         \u001b[0msess\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_step\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfeed_dict_to_use\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36mrun\u001b[1;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[0;32m    948\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    949\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[1;32m--> 950\u001b[1;33m                          run_metadata_ptr)\n\u001b[0m\u001b[0;32m    951\u001b[0m       \u001b[1;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    952\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_run\u001b[1;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[0;32m   1171\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mhandle\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1172\u001b[0m       results = self._do_run(handle, final_targets, final_fetches,\n\u001b[1;32m-> 1173\u001b[1;33m                              feed_dict_tensor, options, run_metadata)\n\u001b[0m\u001b[0;32m   1174\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1175\u001b[0m       \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_do_run\u001b[1;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[0;32m   1348\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1349\u001b[0m       return self._do_call(_run_fn, feeds, fetches, targets, options,\n\u001b[1;32m-> 1350\u001b[1;33m                            run_metadata)\n\u001b[0m\u001b[0;32m   1351\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1352\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_do_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_prun_fn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfeeds\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfetches\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m_do_call\u001b[1;34m(self, fn, *args)\u001b[0m\n\u001b[0;32m   1368\u001b[0m           \u001b[1;32mpass\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1369\u001b[0m       \u001b[0mmessage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0merror_interpolation\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minterpolate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_graph\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1370\u001b[1;33m       \u001b[1;32mraise\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnode_def\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mop\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1371\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1372\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_extend_graph\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mInvalidArgumentError\u001b[0m: 2 root error(s) found.\n  (0) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[node conv2d_transpose (defined at <ipython-input-28-5ac50f1105ca>:23) ]]\n\t [[adam_vars/gradients/vgg_16/fc8_2/conv_pool3/BiasAdd_grad/BiasAddGrad/_99]]\n  (1) Invalid argument: Conv2DSlowBackpropInput: Size of out_backprop doesn't match computed: actual = 11, computed = 12 spatial_dim: 2 input: 23 filter: 4 output: 11 stride: 2 dilation: 1\n\t [[node conv2d_transpose (defined at <ipython-input-28-5ac50f1105ca>:23) ]]\n0 successful operations.\n0 derived errors ignored.\n\nErrors may have originated from an input operation.\nInput Source operations connected to node conv2d_transpose:\n Shape_2 (defined at <ipython-input-28-5ac50f1105ca>:21)\t\n vgg_16/fc8/t_conv_x2/read (defined at <ipython-input-28-5ac50f1105ca>:17)\t\n vgg_16/fc8/BiasAdd (defined at C:\\Users\\ZHAOJU~1\\AppData\\Local\\Temp\\tmp_w6k0wcb.py:56)\n\nInput Source operations connected to node conv2d_transpose:\n Shape_2 (defined at <ipython-input-28-5ac50f1105ca>:21)\t\n vgg_16/fc8/t_conv_x2/read (defined at <ipython-input-28-5ac50f1105ca>:17)\t\n vgg_16/fc8/BiasAdd (defined at C:\\Users\\ZHAOJU~1\\AppData\\Local\\Temp\\tmp_w6k0wcb.py:56)\n\nOriginal stack trace for 'conv2d_transpose':\n  File \"D:\\Anaconda\\lib\\runpy.py\", line 193, in _run_module_as_main\n    \"__main__\", mod_spec)\n  File \"D:\\Anaconda\\lib\\runpy.py\", line 85, in _run_code\n    exec(code, run_globals)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py\", line 16, in <module>\n    app.launch_new_instance()\n  File \"D:\\Anaconda\\lib\\site-packages\\traitlets\\config\\application.py\", line 664, in launch_instance\n    app.start()\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 563, in start\n    self.io_loop.start()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 148, in start\n    self.asyncio_loop.run_forever()\n  File \"D:\\Anaconda\\lib\\asyncio\\base_events.py\", line 534, in run_forever\n    self._run_once()\n  File \"D:\\Anaconda\\lib\\asyncio\\base_events.py\", line 1771, in _run_once\n    handle._run()\n  File \"D:\\Anaconda\\lib\\asyncio\\events.py\", line 88, in _run\n    self._context.run(self._callback, *self._args)\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\ioloop.py\", line 690, in <lambda>\n    lambda f: self._run_callback(functools.partial(callback, future))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\ioloop.py\", line 743, in _run_callback\n    ret = callback()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 787, in inner\n    self.run()\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 748, in run\n    yielded = self.gen.send(value)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 365, in process_one\n    yield gen.maybe_future(dispatch(*args))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 272, in dispatch_shell\n    yield gen.maybe_future(handler(stream, idents, msg))\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 542, in execute_request\n    user_expressions, allow_stdin,\n  File \"D:\\Anaconda\\lib\\site-packages\\tornado\\gen.py\", line 209, in wrapper\n    yielded = next(result)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 294, in do_execute\n    res = shell.run_cell(code, store_history=store_history, silent=silent)\n  File \"D:\\Anaconda\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 536, in run_cell\n    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2855, in run_cell\n    raw_cell, store_history, silent, shell_futures)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2881, in _run_cell\n    return runner(coro)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 68, in _pseudo_sync_runner\n    coro.send(None)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3058, in run_cell_async\n    interactivity=interactivity, compiler=compiler, result=result)\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3249, in run_ast_nodes\n    if (await self.run_code(code, result,  async_=asy)):\n  File \"D:\\Anaconda\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3326, in run_code\n    exec(code_obj, self.user_global_ns, self.user_ns)\n  File \"<ipython-input-28-5ac50f1105ca>\", line 23, in <module>\n    padding='SAME')\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\nn_ops.py\", line 2147, in conv2d_transpose\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\nn_ops.py\", line 2218, in conv2d_transpose_v2\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\ops\\gen_nn_ops.py\", line 1529, in conv2d_backprop_input\n    name=name)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py\", line 788, in _apply_op_helper\n    op_def=op_def)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\util\\deprecation.py\", line 507, in new_func\n    return func(*args, **kwargs)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\", line 3616, in create_op\n    op_def=op_def)\n  File \"D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py\", line 2005, in __init__\n    self._traceback = tf_stack.extract_stack()\n"
     ]
    }
   ],
   "source": [
    "init_op = tf.global_variables_initializer()\n",
    "sess_config = tf.ConfigProto()\n",
    "sess_config.gpu_options.allow_growth = True\n",
    "sess = tf.Session(config=sess_config)\n",
    "\n",
    "with sess:\n",
    "\n",
    "    # Run the initializers.\n",
    "    sess.run(vgg_fc8_weights_initializer)\n",
    "    sess.run(optimization_variables_initializer)\n",
    "    read_vgg_weights_except_fc8_func(sess)\n",
    "\n",
    "    train_image, train_annotation = sess.run(\n",
    "        [image_tensor, annotation_tensor], feed_dict=feed_dict_to_use)\n",
    "\n",
    "    f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
    "    ax1.imshow(train_image)\n",
    "    ax1.set_title('Input image')\n",
    "    probability_graph = ax2.imshow(np.dstack((train_annotation, ) * 3) * 100)\n",
    "    ax2.set_title('Input Ground-Truth Annotation')\n",
    "    plt.show()\n",
    "\n",
    "    # Let's perform 10 interations\n",
    "    for i in range(10):\n",
    "        loss, summary_string = sess.run(\n",
    "            [cross_entropy_sum, merged_summary_op], feed_dict=feed_dict_to_use)\n",
    "\n",
    "        sess.run(train_step, feed_dict=feed_dict_to_use)\n",
    "\n",
    "        pred_np, probabilities_np = sess.run(\n",
    "            [pred, probabilities], feed_dict=feed_dict_to_use)\n",
    "\n",
    "        summary_string_writer.add_summary(summary_string, i)\n",
    "\n",
    "        cmap = plt.get_cmap('bwr')\n",
    "\n",
    "        f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)\n",
    "        ax1.imshow(\n",
    "            np.uint8(pred_np.squeeze() != 1), vmax=1.5, vmin=-0.4, cmap=cmap)\n",
    "        ax1.set_title('Argmax. Iteration # ' + str(i))\n",
    "        probability_graph = ax2.imshow(probabilities_np.squeeze()[:, :, 0])\n",
    "        ax2.set_title('Probability of the Class. Iteration # ' + str(i))\n",
    "        mask = np.multiply(np.uint32(pred_np.squeeze()), 128)\n",
    "        mask = np.stack(\n",
    "            [\n",
    "                mask,\n",
    "            ] * 3, axis=-1)\n",
    "        masked_image = np.uint8(np.clip(train_image + mask, 0, 255))\n",
    "        probability_graph = ax3.imshow(masked_image)\n",
    "        plt.colorbar(probability_graph)\n",
    "        plt.show()\n",
    "\n",
    "        print(\"Current Loss: \" + str(loss))\n",
    "\n",
    "    feed_dict_to_use[is_training_placeholder] = False\n",
    "\n",
    "    final_predictions, final_probabilities, final_loss = sess.run(\n",
    "        [pred, probabilities, cross_entropy_sum], feed_dict=feed_dict_to_use)\n",
    "\n",
    "    f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)\n",
    "\n",
    "    ax1.imshow(\n",
    "        np.uint8(final_predictions.squeeze() != 1),\n",
    "        vmax=1.5,\n",
    "        vmin=-0.4,\n",
    "        cmap=cmap)\n",
    "\n",
    "    ax1.set_title('Final Argmax')\n",
    "\n",
    "    probability_graph = ax2.imshow(final_probabilities.squeeze()[:, :, 0])\n",
    "    ax2.set_title('Final Probability of the Class')\n",
    "    plt.colorbar(probability_graph)\n",
    "\n",
    "    mask = np.multiply(np.uint32(final_predictions.squeeze()), 128)\n",
    "    #mask = np.stack([mask,]*3, axis=-1)\n",
    "    mask = np.stack(\n",
    "        [np.zeros(mask.shape), mask,\n",
    "         np.zeros(mask.shape)], axis=-1)\n",
    "    masked_image = np.uint8(np.clip(train_image + mask, 0, 255))\n",
    "    probability_graph = ax3.imshow(masked_image)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "    print(\"Final Loss: \" + str(final_loss))\n",
    "\n",
    "summary_string_writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8Xfcn就是将32xfcn的feature map扩大2倍（上采样），然后与poo4经过分类器的feature map进行相加，\n",
    "这样，新的feature map就变为原图的16分之一，保留的信息比之前的32分之一更多，\n",
    "接着，将新的feature map再扩大2倍（上采样），然后与pool3经过分类器的feature map进行相加，\n",
    "这样，新的feature map就变为原图的8分之一，保留的信息比之前的16分之一又要更多，\n",
    "最后，将8分之一原图大小的feature map扩大8倍，变为原图等大，\n",
    "这样，最终的feature map比将原图32分之一大小的feature map扩大为原图大小的feature map所保留的信息要多很多\n",
    "\n",
    "fcn就是将图片不断的进行卷积，池化，最终输出个原图32分之一大小的feature map，\n",
    "feature map上的每一个像素点都代表原图的32x32大小的一块区域，\n",
    "接着，对feature map进行上采样，变为原图等大，然后将最终的feature map与标签进行损失计算，从而优化各个参数。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
